#
#   Copyright 2011 Wade Alcorn wade@bindshell.net
#
#   Licensed under the Apache License, Version 2.0 (the "License");
#   you may not use this file except in compliance with the License.
#   You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.
#

module BeEF
module Core

  # @note This module contains a list of utils functions to use when writing commands
  module CommandUtils
    
    # Format a string to support multiline in javascript.
    # @param [String] text String to convert
    # @return [String] Formatted string
    def format_multiline(text); text.gsub(/\n/, '\n'); end
    
  end


  
  # @note The Command Module Context is being used when evaluating code in eruby.
  #   In other words, we use that code to add funky functions to the
  #   javascript templates of our commands.
  class CommandContext < Erubis::Context
    include BeEF::Core::CommandUtils
    
    # Constructor
    # @param [Hash] hash
    def initialize(hash=nil); 
      super(hash); 
    end
    
  end
  
  # @note This class is the base class for all command modules in the framework.
  #   Two instances of this object are created during the execution of command module.
  class Command
  
    attr_reader :datastore, :path, :default_command_url, :beefjs_components, :friendlyname
    attr_accessor :zombie, :command_id, :session_id
    
    include BeEF::Core::CommandUtils
    include BeEF::Core::Constants::Browsers
    include BeEF::Core::Constants::CommandModule

    # Super class controller
    # @param [String] key command module key
    def initialize(key)
      get_extensions
      config = BeEF::Core::Configuration.instance

      @key = key
      @datastore = {}
      @friendlyname = config.get("beef.module.#{key}.name")
      @output = ''
      @path = config.get("beef.module.#{key}.path")
      @default_command_url = config.get("beef.module.#{key}.mount")
      @id = config.get("beef.module.#{key}.db.id")
      @auto_update_zombie = false
      @results = {}
      @beefjs_components = {}
    end
    
    # Uses the API to include all the code from extensions that need to add methods, constants etc to that class.
    # @todo Determine if this method is deprecated
    def get_extensions
      BeEF::API::Command.extended_in_modules.each do |mod|
        self.class.send(:include, mod)
      end
    end
    
    # This function is called just before the instructions are sent to hooked browser.
    def pre_send; end
    
    # Callback method. This function is called when the hooked browser sends results back.
    def callback; end
    
    # If the command requires some data to be sent back, this function will process them.
    # @param [] head
    # @param [Hash] params Hash of parameters
    # @todo Determine argument "head" type
    def process_zombie_response(head, params); end
    
    # Returns true if the command needs configurations to work. False if not.
    # @deprecated This command should not be used since the implementation of the new configuration system
    def needs_configuration?; !@datastore.nil?; end
    
    # Returns information about the command in a JSON format.
    # @return [String] JSON formatted string
    def to_json
       {
        'Name'          => @friendlyname,
        'Description'   => BeEF::Core::Configuration.instance.get("beef.module.#{@key}.description"),
        'Category'      => BeEF::Core::Configuration.instance.get("beef.module.#{@key}.category"),
        'Data'          => BeEF::Module.get_options(@key)            
      }.to_json
    end
    
    # Builds the 'datastore' attribute of the command which is used to generate javascript code.
    # @param [Hash] data Data to be inserted into the datastore
    # @todo Confirm argument "data" type
    def build_datastore(data); 
      @datastore = JSON.parse(data)
    end
    
    # Sets the datastore for the callback function. This function is meant to be called by the CommandHandler
    # @param [Hash] http_params HTTP parameters
    # @param [Hash] http_headers HTTP headers
    def build_callback_datastore(http_params, http_headers)
      @datastore = {'http_headers' => {}} # init the datastore
      
      # get, check and add the http_params to the datastore
      http_params.keys.each { |http_params_key|
        (print_error 'http_params_key is invalid';return) if not BeEF::Filters.is_valid_command_module_datastore_key?(http_params_key)
        http_params_value = Erubis::XmlHelper.escape_xml(http_params[http_params_key])
        (print_error 'http_params_value is invalid';return) if not BeEF::Filters.is_valid_command_module_datastore_param?(http_params_value)
        @datastore[http_params_key] = http_params_value # add the checked key and value to the datastore
      }

      # get, check and add the http_headers to the datastore
      http_headers.keys.each { |http_header_key|
        (print_error 'http_header_key is invalid';return) if not BeEF::Filters.is_valid_command_module_datastore_key?(http_header_key)
        http_header_value = Erubis::XmlHelper.escape_xml(http_headers[http_header_key][0])
        (print_error 'http_header_value is invalid';return) if not BeEF::Filters.is_valid_command_module_datastore_param?(http_header_value)
        @datastore['http_headers'][http_header_key] = http_header_value # add the checked key and value to the datastore
      } 
    end
    
    # Returns the output of the command. These are the actual instructions sent to the browser.
    # @return [String] The command output
    def output
        f = @path+'command.js'
        (print_error "#{f} file does not exist";return) if not File.exists? f

        command = BeEF::Core::Models::Command.first(:id => @command_id)
        
        @eruby = Erubis::FastEruby.new(File.read(f)) 

        data = BeEF::Core::Configuration.instance.get("beef.module.#{@key}")
        cc = BeEF::Core::CommandContext.new
        cc['command_url'] = @default_command_url
        cc['command_id'] = @command_id
        JSON.parse(command['data']).each{|v|
            cc[v['name']] = v['value']
        }
        if self.respond_to?(:execute)
            self.execute
        end
        @output = @eruby.evaluate(cc)
      
      @output
    end
    
    # Saves the results received from the hooked browser
    # @param [Hash] results Results from hooked browser
    def save(results)
      @results = results
    end

    # If nothing else than the file is specified, the function will map the file to a random path without any extension.
    # @param [String] file File to be mounted
    # @param [String] path URL path to mounted file
    # @param [String] extension URL extension
    # @param [Integer] count The amount of times this file can be accessed before being automatically unmounted
    # @deprecated This function is possibly deprecated in place of the API
    def map_file_to_url(file, path=nil, extension=nil, count=1)
           return  BeEF::Core::NetworkStack::Handlers::AssetHandler.instance.bind(file, path, extension, count)
    end
    
    # Tells the framework to load a specific module of the BeEFJS library that the command will be using.
    # @param [String] component String of BeEFJS component to load
    # @note Example: use 'beef.net.local'
    def use(component)
      return if @beefjs_components.include? component
      
      component_path = '/'+component
      component_path.gsub!(/beef./, '')
      component_path.gsub!(/\./, '/')
      component_path.replace "#{$root_dir}/core/main/client/#{component_path}.js"
      
      raise "Invalid beefjs component for command module #{@path}" if not File.exists?(component_path)
      
      @beefjs_components[component] = component_path
    end

    # @todo Document
    def oc_value(name)
        option =  BeEF::Core::Models::OptionCache.first(:name => name)
		return nil if not option
      	return option.value
	end

    # @todo Document
	def apply_defaults()
	    @datastore.each { |opt|
		    opt["value"] = oc_value(opt["name"]) || opt["value"]
		}
	end
  
    private
    
    @use_template
    @eruby
    @update_zombie
    @results
    
  end
  

end
end
